package co.com.colcomercio.util;

import java.math.BigDecimal;
import java.sql.Date;
import java.sql.Timestamp;
import java.text.NumberFormat;
import java.util.StringTokenizer;

import co.com.colcomercio.util.constants.GeneralConstants;
import co.com.colcomercio.util.exception.OperacionException;

public class Formatos {

private static String SEPARADOR_MILES = ",";
	
	private static String SEPARADOR_DECIMALES = ".";
		
	/**
	 * Este metodo permite asignar el tipo de separador que se va a usar para toda
	 * la aplicacion.
	 * @param separador_decimales
	 */
	public static void setTipo_SeparadoresNumericos(String separador_miles, String separador_decimales) {
		
		SEPARADOR_MILES = separador_miles;
		SEPARADOR_DECIMALES = separador_decimales;
	}



	public static String getSEPARADOR_MILES() {
		return SEPARADOR_MILES;
	}

	
	public static String getSEPARADOR_DECIMALES() {
		return SEPARADOR_DECIMALES;
	}

	public static String quitarSaltos(String frase){
		String texto="";
		String texto2="";
		String resultado="";
		String [] cadSplitBackN = frase.split("\n");
		for( int i = 0; i < cadSplitBackN.length; i++ ){
			texto = texto + cadSplitBackN[i]+" ";
		}
		String [] cadSplitBackR = texto.split("\r");
		for( int i = 0; i < cadSplitBackR.length; i++ ){
			texto2 = texto2 + cadSplitBackR[i] + " ";
		}
		String [] cadSplitBackT = texto2.split("\t");
		for( int i = 0; i < cadSplitBackT.length; i++ ){
			resultado = resultado + cadSplitBackT[i] + " ";
		}
		return resultado;
	}


	/**
	 * Este Metodo Recibe un valor numerico con el siguiente formato:
	 * 100,000.00; donde el signo (,) es el separador de miles y el 
	 * signo (.) representa el separador de decimales.
	 * 
	 * Retorna un Bigdecimal, de la siguiente forma 100000.00
	 * @param valor
	 * @return BigDecimal
	 * @throws Exception
	 */
	public static BigDecimal quitarFormato(String valor) throws Exception {
		BigDecimal valorSinFormato = new BigDecimal(0);
		try {
			int index = 0;
			String temp = valor;
			
			for (int i = 0; i < temp.length(); i++) {
				index = temp.indexOf(SEPARADOR_MILES);
				
				if (index > 0) {
					temp = temp.substring(0, index) + temp.substring(index + 1);
					i = index;
				}
				else {
					i = temp.length() + 1;
					
				}
			}
			
			valorSinFormato = new BigDecimal(temp);
		}
		catch (Exception e) {
			throw e;
		}
		return valorSinFormato;
	}
	
	public static String formatoTextoCapitalizadoRsa(String texto){
		String res= " Asistencia RSA";
		return res;
	}
	
	
	/**
	 * Este Metodo recibe un valor numerico de tipo double y
	 * le coloca formato de la siguiente manera:
	 * 
	 * Recibe el valor 100000.25
	 * Retorna el valor 100,000.25
	 * 
	 * Los separadores empleados seran los asignados a la aplicacion, a traves
	 * del metodo setTipo_SeparadoresNumericos(String separador_miles, String separador_decimales).
	 * Si estos no son asignados, por defecto, el signo (,) es el separador de miles y el 
	 * signo (.) representa el separador de decimales.
	 * @param double valor
	 * @return String
	 */
	public static String numberFormat(double valor) {
		
		return putNumberFormat(new BigDecimal(valor), SEPARADOR_DECIMALES, SEPARADOR_MILES);
	}
	
	
	/**
	 * Este Metodo recibe un valor numerico de tipo BigDecimal y
	 * le coloca formato de la siguiente manera:
	 * 
	 * Recibe el valor 100000.25
	 * Retorna el valor 100,000.25
	 * 
	 * Los separadores empleados seran los asignados a la aplicacion, a traves
	 * del metodo setTipo_SeparadoresNumericos(String separador_miles, String separador_decimales).
	 * Si estos no son asignados, por defecto, el signo (,) es el separador de miles y el 
	 * signo (.) representa el separador de decimales.
	 * @param BigDecimal valor
	 * @return String
	 */
	public static String numberFormat(BigDecimal valor) {
		
		return putNumberFormat(valor, SEPARADOR_DECIMALES, SEPARADOR_MILES);
	}
	
	
	/**
	 * Este Metodo recibe un valor numerico de tipo String y
	 * le coloca formato de la siguiente manera:
	 * 
	 * Recibe el valor 100000.25
	 * Retorna el valor 100,000.25
	 * 
	 * Los separadores empleados seran los asignados a la aplicacion, a traves
	 * del metodo setTipo_SeparadoresNumericos(String separador_miles, String separador_decimales).
	 * Si estos no son asignados, por defecto, el signo (,) es el separador de miles y el 
	 * signo (.) representa el separador de decimales.
	 * @param String valor
	 * @return String
	 */
	public static String numberFormat(String valor) {
		
		if (valor == null) {
			
			valor = GeneralConstants.STRING_ZERO;
		}
		
		return putNumberFormat(new BigDecimal(valor), SEPARADOR_DECIMALES, SEPARADOR_MILES);
	}
	
	/**
	 * Este Metodo recibe un valor numerico de tipo double y
	 * le coloca formato de la siguiente manera:
	 * 
	 * Recibe el valor 100000.25
	 * Retorna el valor 100,000.25
	 * 
	 * Ajustando el resultado al numero de decimales indicado por parametro.
	 * 
	 * Los separadores empleados seran los asignados a la aplicacion, a traves
	 * del metodo setTipo_SeparadoresNumericos(String separador_miles, String separador_decimales).
	 * Si estos no son asignados, por defecto, el signo (,) es el separador de miles y el 
	 * signo (.) representa el separador de decimales.
	 * @param double valor
	 * @param int numDecimales
	 * @return String
	 */
	public static String numberFormat(double valor, int numDecimales) {
		
		BigDecimal valorRed = redondear(valor, numDecimales);
		
		return putNumberFormat(valorRed, SEPARADOR_DECIMALES, SEPARADOR_MILES);
	}
	
	
	/**
	 * Este Metodo recibe un valor numerico de tipo BigDecimal y
	 * le coloca formato de la siguiente manera:
	 * 
	 * Recibe el valor 100000.25
	 * Retorna el valor 100,000.25
	 * 
	 * Ajustando el resultado al numero de decimales indicado por parametro.
	 * 
	 * Los separadores empleados seran los asignados a la aplicacion, a traves
	 * del metodo setTipo_SeparadoresNumericos(String separador_miles, String separador_decimales).
	 * Si estos no son asignados, por defecto, el signo (,) es el separador de miles y el 
	 * signo (.) representa el separador de decimales.
	 * @param BigDecimal valor
	 * @param int numDecimales
	 * @return String
	 */
	public static String numberFormat(BigDecimal valor, int numDecimales) {
		
		if (valor != null) {
			
			BigDecimal valorRed = redondear(valor.doubleValue(), numDecimales);
			
			return putNumberFormat(valorRed, SEPARADOR_DECIMALES, SEPARADOR_MILES);
		}
		else {
			
			return GeneralConstants.STRING_ZERO;
		}
	}
	
	
	/**
	 * Este Metodo recibe un valor numerico de tipo double y
	 * le coloca formato de la siguiente manera:
	 * 
	 * Recibe el valor 100000.25
	 * Retorna el valor 100,000.25
	 * 
	 * Los separadores empleados seran los asignados a la aplicacion, a traves
	 * del metodo setTipo_SeparadoresNumericos(String separador_miles, String separador_decimales).
	 * Si estos no son asignados, por defecto, el signo (,) es el separador de miles y el 
	 * signo (.) representa el separador de decimales.
	 * @param double valor
	 * @return String
	 */
	public static String putNumberFormat(BigDecimal valor, String separadorDec, String separadorMiles) {
		
		if (valor != null) {
			
		      String num = valor +""; 
		      String signo = num.substring(0, 1);  
		      
		       
		      int posDec = num.indexOf(separadorDec);

		      if(posDec == -1)
		      {
		      	posDec = num.length();
		      }
		      

		      
			  int posSigno = 0;
		      
			  if(signo.equals("+") || signo.equals("-"))
			  {
				  num = num.substring(1);			
				  posDec --;
			  }
			  else
			  {			  
				  signo = "";
			  }	      	
			  

		      String cad = "";
		      String temp = "";
			  int pos = posDec;

		      
		      while(posSigno < pos)
		      {
		   		pos -= 3;
		      	temp = cad;
		  		if(pos > 0)
		  		{
			      	String cad1 = num.substring(pos, pos+3);	
					cad = separadorMiles +cad1+ temp;
		  		}
		  		else
		  		{
			      	String cad1 = num.substring(0, pos+3);	
					cad = cad1+ temp;
		  		}
		      }

			  if(posDec < num.length())
			  {
			  	cad += num.substring(posDec, num.length());
			  }
			  
			  if(cad == "")
			  {
			  	cad = "0";
			  }		  
			  
		      return signo + cad;	
		}
		else {
			
			return GeneralConstants.STRING_ZERO;
		}
	}
	
	
	private static BigDecimal redondear(double valor, int numDec) {
		double potencia = Math.pow(10, numDec);
		double valorOrig = valor;

		BigDecimal valorRed = new BigDecimal(Math.round(valorOrig * potencia) / potencia);

		return valorRed;
	}
	
	
	public static String quitarFormatonit(String str) throws Exception {
		try {
			String n = null;
			
			if (str.trim().length() > 9) {
				int a = str.indexOf("-");
				
				if (a > 0) {
					String b = str.substring(0, a);
					BigDecimal nit = quitarFormato(b);
					n = nit.toString() + str.substring(a + 1, str.length());
				}
				else {
					n = quitarFormato(str).toString();
				}
				
			}
			else {
				n = quitarFormato(str).toString();
			}
			return n;
		}
		catch (Exception e) {
			Exception ex = new Exception("Debe digitar un número");
			throw ex;
		}
	}
	
	
	public static String formatoNit(String str) {
		String nit = null;
		if (str.equals(null)) {
			nit = GeneralConstants.BLANK;
		}
		else {
			try {
				NumberFormat num = NumberFormat.getInstance();
				String parte1 = null;
				String parte2 = null;
				
				parte1 = str.substring(0, str.length() - 1);
				parte2 = str.substring(str.length() - 1, str.length());
				nit = num.format(Long.parseLong(parte1)) + "-" + parte2;
				
				
			}
			catch (Exception e) {
				nit = str + " error";
			}
		}
		
		return nit;
	}
			
	/**
	 * Este método le asigna formato de Fecha (2004-01-15) a una cadena que
	 * tenga la siguiente estructura (20040115).
	 */
	public static String formatoDate(String str) {
		
		try {
			
			if (str.trim().length() >= 8) {
				String parte1 = null;
				String parte2 = null;
				String parte3 = null;
				
				parte1 = str.substring(0, 4);
				parte2 = str.substring(4, 6);
				parte3 = str.substring(6, 8);
				
				str = parte1 + "-" + parte2 + "-" + parte3;
			}
			else {
				str = GeneralConstants.BLANK;
			}
			
		}
		catch (Exception e) {
		}
		
		return str;
	}
	

	
	
	
	/**
	 * Este método le asigna formato de Fecha (2004-01-15) a una cadena que
	 * tenga la siguiente estructura (20040115).
	 */
	public static String formatoTime(String str) {
		
		try {
			if (str.trim().length() < 6) {
				str = "000000";
			}
			String parte1 = null;
			String parte2 = null;
			String parte3 = null;
			
			parte1 = str.substring(0, 2);
			parte2 = str.substring(2, 4);
			parte3 = str.substring(4, 6);
			
			str = parte1 + ":" + parte2 + ":" + parte3 + ".0";
		}
		catch (Exception e) {
		}
		
		return str;
	}
	
	
	
	/**
	 * Este método le asigna formato de Fecha (2004/01/15) a una cadena que
	 * tenga la siguiente estructura (2004-01-15).
	 */
	public static String formatoFechas(String str) {
		
		try {
			
			String parte1 = null;
			String parte2 = null;
			String parte3 = null;
			
			parte1 = str.substring(0, 4);
			parte2 = str.substring(5, 7);
			parte3 = str.substring(8, 10);
			
			str = parte1 + "/" + parte2 + "/" + parte3;
			
		}
		catch (Exception e) {
			System.out.println(e);
		}
		
		return str;
	}
	

	
	/**
	 * Este método le asigna formato de Fecha (2004/01/15) a una cadena que
	 * tenga la siguiente estructura (2004-01-15).
	 */
	public static String formatoYYYYMMDD_to_DDMMYYYY(String str) {
		
		try {
			
			String parte1 = null;
			String parte2 = null;
			String parte3 = null;
			
			parte1 = str.substring(0, 4);
			parte2 = str.substring(5, 7);
			parte3 = str.substring(8, 10);
			
			str = parte3 + "/" + parte2 + "/" + parte1;
			
		}
		catch (Exception e) {
			System.out.println(e);
		}
		
		return str;
	}
	
	/**
	 * Este método le asigna formato de Fecha (20040115) a una cadena que
	 * tenga la siguiente estructura (15/01/2014).
	 */
	public static String formatoDDMMYYYY_to_YYYYMMDD(String str) {
		
		try {
			
			String parte1 = null;
			String parte2 = null;
			String parte3 = null;
			
			
			parte1 = str.substring(6, 10);
			parte2 = str.substring(3, 5);
			parte3 = str.substring(0, 2);
			
			
			str = parte1 +  parte2 +  parte3;			
		}
		catch (Exception e) {
			System.out.println(e);
		}
		
		return str;
	}

	/**
	 * Este metoto cambia el año de una fecha con formato DD/MM/YYYY
	 * dejandolo YYYY/MM/DD
	 * Mantiene el simbolo separador
	 * @param str
	 * @param isYearFirst
	 * @return
	 */
	public static String changeYearPosition(String str, boolean isYearFirst) {
		
		try {
			
			String parte1 = null;
			String parte2 = null;
			String parte3 = null;
			
			if(isYearFirst)
			{
				//	YYYY/MM/DD
				parte1 = str.substring(0, 4);
				parte2 = str.substring(5, 7);
				parte3 = str.substring(8, 10);
			}				
			else
			{
				//	DD/MM/YYYY
				parte1 = str.substring(6, 10);
				parte2 = str.substring(3, 5);
				parte3 = str.substring(0, 2);
			}
			
			str = parte1 + "/" + parte2 + "/" + parte3;
			
		}
		catch (Exception e) {
			System.out.println(e);
		}
		
		return str;
	}

	public static String changeYearPositionLinea(String str, boolean isYearFirst) {
		
		try {
			
			String parte1 = null;
			String parte2 = null;
			String parte3 = null;
			
			if(isYearFirst)
			{
				//	YYYY/MM/DD
				parte1 = str.substring(0, 4);
				parte2 = str.substring(5, 7);
				parte3 = str.substring(8, 10);
			}				
			else
			{
				//	DD/MM/YYYY
				parte1 = str.substring(6, 10);
				parte2 = str.substring(3, 5);
				parte3 = str.substring(0, 2);
			}
			
			str = parte1 + "-" + parte2 + "-" + parte3;
			
		}
		catch (Exception e) {
			System.out.println(e);
		}
		
		return str;
	}
	/**
	 * Este metoto cambia el año de una fecha con formato DD/MM/YYYY
	 * dejandolo YYYY-MM-DD
	 * Mantiene el simbolo separador
	 * @param str
	 * @param isYearFirst
	 * @return
	 */
	public static String changeYearPositionG(String str, boolean isYearFirst) {
		
		try {
			
			String parte1 = null;
			String parte2 = null;
			String parte3 = null;
			
			if(isYearFirst)
			{
				//	YYYY/MM/DD
				parte1 = str.substring(0, 4);
				parte2 = str.substring(5, 7);
				parte3 = str.substring(8, 10);
			}				
			else
			{
				//	DD/MM/YYYY
				parte1 = str.substring(6, 10);
				parte2 = str.substring(3, 5);
				parte3 = str.substring(0, 2);
			}
			
			str = parte1 + "-" + parte2 + "-" + parte3;
			
		}
		catch (Exception e) {
			System.out.println(e);
		}
		
		return str;
	}

	
	
	/**
	 * Este método le asigna formato de Fecha (15/01/2004) a una cadena que
	 * tenga la siguiente estructura (2004-01-15).
	 */
	public static String formatoFechasDMY(String str) {
		
		try {
			
			String parte1 = null;
			String parte2 = null;
			String parte3 = null;
			
			parte1 = str.substring(0, 4);
			parte2 = str.substring(5, 7);
			parte3 = str.substring(8, 10);
			
			str = parte3 + "/" + parte2 + "/" + parte1;
			
		}
		catch (Exception e) {
			System.out.println(e);
		}
		
		return str;
	}
	
	
	/**
	 * Este método le asigna formato de Fecha (Ene. 15 de 2004) a una cadena que
	 * tenga la siguiente estructura (20040115).
	 */
	public static String formatoFecha(String str) {
		
		try {
			String parte1 = null;
			String parte2 = null;
			String parte3 = null;
			parte1 = str.substring(0, 4);
			parte2 = str.substring(4, 6);
			parte3 = str.substring(6, 8);
			
			if (parte2.trim().equals("01")) {
				parte2 = "Ene.";
			}
			if (parte2.trim().equals("02")) {
				parte2 = "Feb.";
			}
			if (parte2.trim().equals("03")) {
				parte2 = "Mar.";
			}
			if (parte2.trim().equals("04")) {
				parte2 = "Abr.";
			}
			if (parte2.trim().equals("05")) {
				parte2 = "May.";
			}
			if (parte2.trim().equals("06")) {
				parte2 = "Jun.";
			}
			if (parte2.trim().equals("07")) {
				parte2 = "Jul.";
			}
			if (parte2.trim().equals("08")) {
				parte2 = "Ago.";
			}
			if (parte2.trim().equals("09")) {
				parte2 = "Sep.";
			}
			if (parte2.trim().equals("10")) {
				parte2 = "Oct.";
			}
			if (parte2.trim().equals("11")) {
				parte2 = "Nov.";
			}
			if (parte2.trim().equals("12")) {
				parte2 = "Dic.";
			}
			
			str = parte2 + " " + parte3 + " de " + parte1;
			
		}
		catch (Exception e) {
			
		}
		
		return str;
	}

	/**
	 * Este método le asigna formato de Fecha (Ene. 15 de 2004) a una cadena que
	 * tenga la siguiente estructura (15/01/2004).
	 */
	public static String formatoFechaddMMaaa(String str) {
		
		try {
			String parte1 = null;
			String parte2 = null;
			String parte3 = null;
			parte1 = str.substring(0, 2);
			parte2 = str.substring(3, 5);
			parte3 = str.substring(6, 10);
			
			if (parte2.trim().equals("01")) {
				parte2 = "Ene.";
			}
			if (parte2.trim().equals("02")) {
				parte2 = "Feb.";
			}
			if (parte2.trim().equals("03")) {
				parte2 = "Mar.";
			}
			if (parte2.trim().equals("04")) {
				parte2 = "Abr.";
			}
			if (parte2.trim().equals("05")) {
				parte2 = "May.";
			}
			if (parte2.trim().equals("06")) {
				parte2 = "Jun.";
			}
			if (parte2.trim().equals("07")) {
				parte2 = "Jul.";
			}
			if (parte2.trim().equals("08")) {
				parte2 = "Ago.";
			}
			if (parte2.trim().equals("09")) {
				parte2 = "Sep.";
			}
			if (parte2.trim().equals("10")) {
				parte2 = "Oct.";
			}
			if (parte2.trim().equals("11")) {
				parte2 = "Nov.";
			}
			if (parte2.trim().equals("12")) {
				parte2 = "Dic.";
			}
			
			str = parte1 + " " + parte2 + " de " + parte3;
			
		}
		catch (Exception e) {
			
		}
		
		return str;
	}
	
	public static String formatoFechaII(String str) {
		
		try {
			String parte1 = null;
			String parte2 = null;
			String parte3 = null;
			parte1 = str.substring(0, 4);
			parte2 = str.substring(4, 6);
			parte3 = str.substring(6, 8);
			
			if (parte2.trim().equals("01")) {
				parte2 = "Enero";
			}
			if (parte2.trim().equals("02")) {
				parte2 = "Febrero";
			}
			if (parte2.trim().equals("03")) {
				parte2 = "Marzo";
			}
			if (parte2.trim().equals("04")) {
				parte2 = "Abril";
			}
			if (parte2.trim().equals("05")) {
				parte2 = "Mayo";
			}
			if (parte2.trim().equals("06")) {
				parte2 = "Junio";
			}
			if (parte2.trim().equals("07")) {
				parte2 = "Julio";
			}
			if (parte2.trim().equals("08")) {
				parte2 = "Agosto";
			}
			if (parte2.trim().equals("09")) {
				parte2 = "Septiembre";
			}
			if (parte2.trim().equals("10")) {
				parte2 = "Octubre";
			}
			if (parte2.trim().equals("11")) {
				parte2 = "Noviembre";
			}
			if (parte2.trim().equals("12")) {
				parte2 = "Diciembre";
			}
			
			str = parte3 + " de " + parte2 + " de " + parte1;
			
		}
		catch (Exception e) {
			
		}
		
		return str;
	}

	/**
	 * Metodo que quita un formato tipo Wed Dec 07 00:00:00 COT 1988
	 * dejandolo como Dic. 07 de 1988
	 * @param str
	 * @return
	 */
	public static String quitarFormatoFechaDate(String str) {
		
		String fecha 	= null;
		String year		= null;
		String month	= null;
		String day		= null;
			
		year 	= str.substring(24,28);
		month 	= str.substring(4,7);
		day 	= str.substring(8,10);

		if (month.equals("Jan")) {
			month = "01";
		}
		if (month.equals("Feb")) {
			month = "02";
		}
		if (month.equals("Mar")) {
			month = "03";
		}
		if (month.equals("Apr")) {
			month = "";
		}
		if (month.equals("May")) {
			month = "05";
		}
		if (month.equals("Jun")) {
			month = "06";
		}
		if (month.equals("Jul")) {
			month = "07";
		}
		if (month.equals("Aug")) {
			month = "08";
		}
		if (month.equals("Sep")) {
			month = "09";
		}
		if (month.equals("Oct")) {
			month = "10";
		}
		if (month.equals("Nov")) {
			month = "11";
		}
		if (month.equals("Dec")) {
			month = "12";
		}

		fecha = formatoFecha(year + month + day);
		
		return fecha;
	}
	
	/**
	 * Metodo que quita un formato tipo Wed Dec 07 00:00:00 COT 1988
	 * dejandolo como Dic. 07 de 1988
	 * @param str
	 * @return
	 */
	public static String quitarFormatoFecha(String str) {
		
		String fecha 	= null;
		String year		= null;
		String month	= null;
		String day		= null;
			
		year 	= str.substring(0,4);
		month 	= str.substring(8,10);
		day 	= str.substring(5,7);

		if (month.equals("01")) {
			month = "Ene";
		}
		if (month.equals("02")) {
			month = "Feb";
		}
		if (month.equals("03")) {
			month = "Mar";
		}
		if (month.equals("04")) {
			month = "Abr";
		}
		if (month.equals("05")) {
			month = "May";
		}
		if (month.equals("06")) {
			month = "Jun";
		}
		if (month.equals("07")) {
			month = "Jul";
		}
		if (month.equals("08")) {
			month = "Ago";
		}
		if (month.equals("09")) {
			month = "Sep";
		}
		if (month.equals("10")) {
			month = "Oct";
		}
		if (month.equals("11")) {
			month = "Nov";
		}
		if (month.equals("12")) {
			month = "Dec";
		}

		fecha = month + ". " + day +" de "+ year  ;
		
		return fecha;
	}

	public static String quitarFormatoDate(String str) {
		
		String fecha 	= null;
		String year		= null;
		String month	= null;
		String day		= null;
			
		year 	= str.substring(0,4);
		month 	= str.substring(5,7);
		day 	= str.substring(8,10);

		fecha = day + "/" + month +"/"+ year;
		
		return fecha;
	}

	public static String dateToNumber(String str) {
		
		String fecha 	= null;
		String year		= null;
		String month	= null;
		String day		= null;
			
		year 	= str.substring(0,4);
		month 	= str.substring(5,7);
		day 	= str.substring(8,10);

		fecha =  year+month+day;
		
		return fecha;
	}

	public static String quitarFormatoDateM(String str) {
		
		String fecha 	= null;
		String year		= null;
		String month	= null;
		String day		= null;
			
		year 	= str.substring(0,4);
		month 	= str.substring(4,6);
		day 	= str.substring(6,8);

		fecha = day + "/" + month +"/"+ year;
		
		return fecha;
	}

	/**
	 * Este método le retira el formato de Fecha (Ene. 15 de 2004) de una cadena
	 * dejándola con la siguiente estructura (20040115).
	 */
	public static BigDecimal quitarFormatoFechaL(String str) throws Exception {
		try {
			String parte1 = null;
			String parte2 = null;
			String parte3 = null;
			
			parte2 = str.substring(0, 3).trim();
			parte1 = str.substring(5, 7);
			parte3 = str.substring(11, 15);
			
			if (parte2.trim().equals("Ene")) {
				parte2 = "01";
			}
			if (parte2.trim().equals("Feb")) {
				parte2 = "02";
			}
			if (parte2.trim().equals("Mar")) {
				parte2 = "03";
			}
			if (parte2.trim().equals("Abr")) {
				parte2 = "04";
			}
			if (parte2.trim().equals("May")) {
				parte2 = "05";
			}
			if (parte2.trim().equals("Jun")) {
				parte2 = "06";
			}
			if (parte2.trim().equals("Jul")) {
				parte2 = "07";
			}
			if (parte2.trim().equals("Ago")) {
				parte2 = "08";
			}
			if (parte2.trim().equals("Sep")) {
				parte2 = "09";
			}
			if (parte2.trim().equals("Oct")) {
				parte2 = "10";
			}
			if (parte2.trim().equals("Nov")) {
				parte2 = "11";
			}
			if (parte2.trim().equals("Dic")) {
				parte2 = "12";
			}
			
			str = parte3 + parte2 + parte1;
			
		}
		catch (Exception e) {
			
		}
		
		return new BigDecimal(str);
	}
	
	
	public static String armarFecha(String ano, String mes, String dia) throws Exception {
		
		try {
			String fecha = null;
			
			fecha = ano + "    ";
			fecha = fecha.substring(0, 4);
			fecha = fecha + mes + "  ";
			fecha = fecha.substring(0, 6);
			fecha = fecha + dia + "  ";
			fecha = fecha.substring(0, 8);
			return fecha;
		}
		catch (Exception ex) {
			throw ex;
		}
	}
	
	
	
	/**
	 * Este método le quita formato de Fecha (20040115) a una cadena que tenga
	 * la siguiente estructura (2004-01-15).
	 */
	public static BigDecimal quitarformatoDate(String str) {
		try {
			
			if (str.trim().length() < 10) {
				str = "0000-00-00";
			}
			
			String parte1 = null;
			String parte2 = null;
			String parte3 = null;
			
			parte1 = str.substring(0, 4);
			parte2 = str.substring(5, 7);
			parte3 = str.substring(8, 10);
			
			str = parte1 + parte2 + parte3;
			
		}
		catch (Exception e) {
		}
		
		return new BigDecimal(str);
	}
	
	/**
	 * Este método le quita formato de Fecha (20120531) a una cadena que tenga
	 * la siguiente estructura (31-05-2012).
	 * @param str
	 * @return
	 */
	public static BigDecimal quitarformatoDateDMY(String str) {
		try {
			if (str.trim().length() < 10) {
				str = "0000-00-00";
			}
			
			String parte1 = null;
			String parte2 = null;
			String parte3 = null;
			
			parte1 = str.substring(6, 10);
			parte2 = str.substring(3, 5);
			parte3 = str.substring(0, 2);
			
			str = parte1 + parte2 + parte3;
			
		}
		catch (Exception e) {
		}
		
		return new BigDecimal(str);
	}
	
	public static BigDecimal quitarformatoDateYMD(String str) {
		try {
			if (str.trim().length() < 10) {
				str = "0000-00-00";
			}
			
			String parte1 = null;
			String parte2 = null;
			String parte3 = null;
			
			parte1 = str.substring(0, 4);
			parte2 = str.substring(5, 7);
			parte3 = str.substring(8, 10);
			
			str = parte1 + parte2 + parte3;
			
		}
		catch (Exception e) {
		}
		
		return new BigDecimal(str);
	}

	public static String timestampValidate(String str) {
		
		if (str.trim().length() != 21) {
			str = "0000-00-00 00:00:00.0";
		}
		return str;
	}
	
	
	
	
	/**
	 * Este método le asigna formato de Fecha (2004-01-15 12:12:12.0) a una
	 * cadena que tenga la siguiente estructura (15/01/2004 - 12:12).
	 */
	public static String formatoFechasDMA(String str) {
		
		try {
			String parte1 = null;
			String parte2 = null;
			String parte3 = null;
			String parte4 = null;
			
			parte1 = str.substring(0, 4);
			parte2 = str.substring(5, 7);
			parte3 = str.substring(8, 10);
			parte4 = str.substring(11, 16);
			
			str = parte3 + "/" + parte2 + "/" + parte1 + " - " + parte4;
			
		}
		catch (Exception e) {
		}
		
		return str;
	}
	
	
	
	/**
	 * Este método le asigna formato de Fecha (Ene. 15 de 2004) a una variable
	 * de tipo Timestamp.
	 */
	public static String formatoTimestamp(Timestamp timestamp) {
		String str = GeneralConstants.BLANK;
		
		try {
			
			str = timestamp.toString();
			
			String parte1 = null;
			String parte2 = null;
			String parte3 = null;
			
			parte1 = str.substring(0, 4);
			parte2 = str.substring(5, 7);
			parte3 = str.substring(8, 10);
			
			str = formatoFecha(parte1 + parte2 + parte3);
			
		}
		catch (Exception e) {
		}
		
		return str;
	}
	
	
	public static String formatoTimestampToFecha(Timestamp timestamp) {
		String str = GeneralConstants.BLANK;
		
		try {
			
			str = timestamp.toString();
			
			String parte1 = null;
			String parte2 = null;
			String parte3 = null;
			
			parte1 = str.substring(0, 4);
			parte2 = str.substring(5, 7);
			parte3 = str.substring(8, 10);
			
			str = formatoFechaII(parte1 + parte2 + parte3);
			
		}
		catch (Exception e) {
		}
		
		return str;
	}
	
	/**
	 * Este método le asigna formato de Fecha (yyyyMMdd) a una variable de tipo
	 * Timestamp.
	 */
	public static BigDecimal timestampToBigDecimal(Timestamp timestamp) {
		String str = GeneralConstants.BLANK;
		
		try {
			
			str = timestampValidate(timestamp.toString());
			
			String parte1 = null;
			String parte2 = null;
			String parte3 = null;
			
			parte1 = str.substring(0, 4);
			parte2 = str.substring(5, 7);
			parte3 = str.substring(8, 10);
			
			str = parte1 + parte2 + parte3;
			
		}
		catch (Exception e) {
		}
		
		return new BigDecimal(str);
	}
	
	/**
	 * Este método le asigna formato de Fecha (dd/MM/yyyy) a una variable de tipo
	 * Timestamp.
	 */
	public static String timestampToString(Timestamp timestamp) {
		String str = GeneralConstants.BLANK;
		
		try {
			
			str = timestampValidate(timestamp.toString());
			
			String parte1 = null;
			String parte2 = null;
			String parte3 = null;
			
			parte1 = str.substring(0, 4);
			parte2 = str.substring(5, 7);
			parte3 = str.substring(8, 10);
			
			str = parte3 +"/"+ parte2+"/"+ parte1;
			
		}
		catch (Exception e) {
		}
		
		return str;
	}
	
	/**
	 * Este método toma una fecha con el formato (yyyyMMdd) y retorna una fecha de tipo
	 * Timestamp.
	 * @throws OperacionException 
	 */
	public static Timestamp stringToTimestamp(String fecha) throws OperacionException {
		String str = GeneralConstants.BLANK;
		
		if (fecha == null || fecha.length() !=8) {
			
			throw new OperacionException("Error al convertir a Timestamp. Fecha invalida.");
		}
		
		str = formatoDate(fecha) + " 00:00:00.0";
		
		return Timestamp.valueOf(str);
	}
	
	/**
	 * Este método toma una fecha con el formato (yyyyMMdd) y retorna una fecha de tipo
	 * Timestamp.
	 * @throws OperacionException 
	 */
	public static Timestamp bigDecimalToTimestamp(BigDecimal fecha) throws OperacionException {
		String str = GeneralConstants.BLANK;
		
		if (fecha == null || fecha.toString().length() !=8) {
			
			throw new OperacionException("Error al convertir a Timestamp. Fecha invalida.");
		}
		
		str = formatoDate(fecha.toString()) + " 00:00:00.0";
		
		return Timestamp.valueOf(str);
	}
	
	public static Date bigDecimalToDate(BigDecimal fecha) throws OperacionException {
		String str = GeneralConstants.BLANK;
		
		if (fecha == null || fecha.toString().length() !=8) {
			
			throw new OperacionException("Error al convertir a Date. Fecha invalida.");
		}
		
		str = formatoDate(fecha.toString());
		
		return Date.valueOf(str);
	}
	
	
	/**
	 * Este método le asigna formato de Fecha (yyyyMMdd) a una fecha String con
	 * formato de Timestamp.
	 */
	public static BigDecimal timestampToBigDecimal(String timestamp) {
		String str = GeneralConstants.BLANK;
		
		try {
			
			str = timestampValidate(timestamp);
			
			String parte1 = null;
			String parte2 = null;
			String parte3 = null;
			
			parte1 = str.substring(0, 4);
			parte2 = str.substring(5, 7);
			parte3 = str.substring(8, 10);
			
			str = parte1 + parte2 + parte3;
			
		}
		catch (Exception e) {
		}
		
		return new BigDecimal(str);
	}
	
	
	
	/**
	 * Este método le asigna formato de Fecha (10 de Abril de 2007) a una cadena
	 * que tenga la siguiente estructura (20070410).
	 */
	public static String formatoFechaddmmaa(String str) {
		
		try {
			String parte1 = null;
			String parte2 = null;
			String parte3 = null;
			parte1 = str.substring(0, 4);
			parte2 = str.substring(4, 6);
			parte3 = str.substring(6, 8);
			if (parte2.trim().equals("01")) {
				parte2 = "Enero";
			}
			if (parte2.trim().equals("02")) {
				parte2 = "Febrero";
			}
			if (parte2.trim().equals("03")) {
				parte2 = "Marzo";
			}
			if (parte2.trim().equals("04")) {
				parte2 = "Abril";
			}
			if (parte2.trim().equals("05")) {
				parte2 = "Mayo";
			}
			if (parte2.trim().equals("06")) {
				parte2 = "Junio";
			}
			if (parte2.trim().equals("07")) {
				parte2 = "Julio";
			}
			if (parte2.trim().equals("08")) {
				parte2 = "Agosto";
			}
			if (parte2.trim().equals("09")) {
				parte2 = "Septiembre";
			}
			if (parte2.trim().equals("10")) {
				parte2 = "Octubre";
			}
			if (parte2.trim().equals("11")) {
				parte2 = "Noviembre";
			}
			if (parte2.trim().equals("12")) {
				parte2 = "Diciembre";
			}
			
			str = parte3 + " de " + parte2 + " de " + parte1;
			
		}
		catch (Exception e) {
			
		}
		
		return str;
	}
	
	/**
	 * Este metodo toma un numero con decimales y retorna el valor 
	 * sin decimales. Por ejemplo, numero igual a 34.54 y numDecimal es igual a 3
	 * al pasar este numero por el metodo tenemos como resultado 34540, donde 540
	 * seria la parte decimal del numero original
	 * 
	 * @param numero - valor con decimales
	 * @param numDecimal - numero de decimales maximo del campo
	 * @return
	 * @throws OperacionException
	 */
	public static String decimalToInteger(String numero, int numDecimal) throws OperacionException {
		
		if (numero.indexOf(",") != -1) {
			throw new OperacionException("El Valor es inválido");
		}
		
		String ceros = "0000";
		StringTokenizer tokenizer = new StringTokenizer(numero, ".");
		String[] numPartes = new String[2];
		
		int i = 0;
		while (tokenizer.hasMoreTokens()) {
			numPartes[i] = tokenizer.nextToken();
			i++;
		}
		
		String parteEntera = numPartes[0];
		String parteDecimal = numPartes[1];
		
		if (parteDecimal == null) {
			return parteEntera + ceros;
		}
		else {
			parteDecimal = parteDecimal.concat(ceros).substring(0, numDecimal);
		}
		
		if (Integer.parseInt(parteDecimal) == 0) {
			return parteEntera;
		}
		
		if (Integer.parseInt(parteEntera) == 0) {
			return parteDecimal;
		}
		
		return parteEntera + parteDecimal;
	}
	
	/**
	 * Este metodo toma un numero entero y retorna el valor 
	 * con decimales. Por ejemplo, numero igual a 34540 y numDecimal es igual a 3
	 * al pasar este numero por el metodo tenemos como resultado 34.540, ya que le
	 * estamos indicando que el numero tenia originalmente tres decimales.
	 * 
	 * @param numero - valor con decimales
	 * @param numDecimal - numero de decimales maximo del campo
	 * @return
	 * @throws OperacionException
	 */
	public static BigDecimal integerToDecimal(String numero, int numDecimal) throws OperacionException {
		
		if (numero.length() < 4) {
			numero = "00000" + numero;
			
			numero = numero.substring(numero.length() - 5, numero.length());
			
		}
		
		String parteDecimal = numero.substring(numero.length() - numDecimal, numero.length());
		
		numero = numero.replaceAll(parteDecimal, "");
		
		parteDecimal = getDecimalSignificative(parteDecimal);
		
		String parteEntera = numero;
		
		if (parteEntera.equals(GeneralConstants.BLANK)) {
			parteEntera = GeneralConstants.STRING_ZERO;
		}
		
		return new BigDecimal(parteEntera + "." + parteDecimal).setScale(numDecimal);
	}
	
	
	
	/**
	 * Metodo que entrega la parte significativa de la parte decimal entregada
	 * como String
	 * 
	 * @param as_value
	 * @return String
	 * 
	 * @author jgomez
	 */
	private static String getDecimalSignificative(String as_value) {
		
		if (as_value.length() > 1) {
			String ls_value = getDecimalSignificative(as_value.substring(1));
			
			if (as_value.charAt(0) != '0' || !ls_value.equals(GeneralConstants.BLANK)) {
				ls_value = (as_value.charAt(0) + ls_value);
			}
			return ls_value;
			
		}
		else {
			
			if (!as_value.equals(GeneralConstants.STRING_ZERO)) {
				return as_value;
			}
			else {
				return GeneralConstants.BLANK;
			}
		}
		
	}
	
	public static String formatoTextoCapitalizado(String texto){
		String textoFormat = "";
		String[] partes = texto.split(" ");
		for(int i = 0; i < partes.length; i++){
			partes[i] = getLastName(partes[i]);			
			textoFormat = textoFormat + " " + partes[i];
		}		
		return textoFormat;
	}
	
	public static String getLastName(String first){   
		if(first.length() > 2){
			String lastPart = first.substring(1).toLowerCase();  
        	String firstLetter = first.substring(0,1).toUpperCase();
            return (firstLetter + lastPart); 
		}else{
			return first.toLowerCase();
		}
		
    }  
	
	public static String formatoTextoprimera(String texto){
		String textoFormat = "";
		textoFormat = getLastName(texto);
		return textoFormat;
	}

	public static final String zeroIzquierda(int value, int size) {
	  String s = "0000000000"+value;
	  return s.substring(s.length() - size);
	}
	
	public static String completarCaracteres(String dato, int tam){
		String texto="";
		int cont=0;
		StringBuffer respuesta=new StringBuffer(tam);
		for (int i = 0; i < dato.length(); i++) {
			char caracter = dato.charAt(i);
				if(cont<=tam){
					respuesta.append(caracter);
				}
			cont++;
		}
		texto=respuesta.toString();
		String aux=" ";
		for (int i = 0; i < tam; i++) {
			aux=aux+" ";
			if(i==(tam-cont)){
				texto = texto + aux.substring(texto.length());
			}	
		}
		return texto;
	}
	public static int numeroCaracteres(String frase){
		int cont=0;
		StringBuffer respuesta=new StringBuffer();
		for (int i = 0; i < frase.length(); i++) {
			char caracter = frase.charAt(i);
				
					respuesta.append(caracter);
				
			cont++;
		}
		return cont;
	}
	public static String numCaracterFrase (String dato,int num){
		String texto="";
		int cont=0;
		StringBuffer respuesta=new StringBuffer(num);
		for (int i = 0; i < dato.length(); i++) {
			char caracter = dato.charAt(i);
				if(cont<=num){
					respuesta.append(caracter);
				}
			cont++;
		}
		texto=respuesta.toString();
		return texto;
	}

	public static Timestamp quitarFormatoFechaTimeStamp(String str) throws OperacionException {
		
		Timestamp fecha 	= null;
		String year		= null;
		String month	= null;
		String day		= null;
			
		year 	= str.substring(24,28);
		month 	= str.substring(4,7);
		day 	= str.substring(8,10);
		
		try {
			if (month.equals("Jan")) {
				month = "01";
			}
			if (month.equals("Feb")) {
				month = "02";
			}
			if (month.equals("Mar")) {
				month = "03";
			}
			if (month.equals("Apr")) {
				month = "";
			}
			if (month.equals("May")) {
				month = "05";
			}
			if (month.equals("Jun")) {
				month = "06";
			}
			if (month.equals("Jul")) {
				month = "07";
			}
			if (month.equals("Aug")) {
				month = "08";
			}
			if (month.equals("Sep")) {
				month = "09";
			}
			if (month.equals("Oct")) {
				month = "10";
			}
			if (month.equals("Nov")) {
				month = "11";
			}
			if (month.equals("Dec")) {
				month = "12";
			}
			fecha = stringToTimestamp(year + month + day);
			
		} catch (OperacionException e) {
			throw new OperacionException("Error al convertir Timestamp, fecha invalida.");
		}
		
		return fecha;
	}

	public static Timestamp cambiarFormatoFechaTimeStamp(String str) throws OperacionException {
		
		Timestamp fecha 	= null;
		String year		= null;
		String month	= null;
		String day		= null;
			
		year 	= str.substring(24,28);
		month 	= str.substring(4,7);
		day 	= str.substring(8,10);
		
		try {
			if (month.equals("Jan")) {
				month = "01";
			}
			if (month.equals("Feb")) {
				month = "02";
			}
			if (month.equals("Mar")) {
				month = "03";
			}
			if (month.equals("Apr")) {
				month = "04";
			}
			if (month.equals("May")) {
				month = "05";
			}
			if (month.equals("Jun")) {
				month = "06";
			}
			if (month.equals("Jul")) {
				month = "07";
			}
			if (month.equals("Aug")) {
				month = "08";
			}
			if (month.equals("Sep")) {
				month = "09";
			}
			if (month.equals("Oct")) {
				month = "10";
			}
			if (month.equals("Nov")) {
				month = "11";
			}
			if (month.equals("Dec")) {
				month = "12";
			}
			fecha = stringToTimestamp(year + month + day);
			
		} catch (OperacionException e) {
			throw new OperacionException("Error al convertir Timestamp, fecha invalida.");
		}
		
		return fecha;
	}

	/**
	 * Este metodo toma una fecha con formato 2014-04-01
	 * y la retorna con formato Oracle 
	 * TO_DATE('2014-04-01 01:01','YYYY-MM-DD HH24:MI')
	 * @param fec
	 * @return
	 */
	public static String stringDateToOracleFormat(String fec, String minutos)
	{
		return "TO_DATE('" + fec + " "+ minutos +"','YYYY-MM-DD HH24:MI')";
	}
	
}
